/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package Gestores;

import ClasesBase.Casillero;
import ClasesBase.Ferrocarril;
import Hilos.HiloCliente;
import ClasesBase.Jugador;
import ClasesBase.Propiedad;
import ClasesBase.ServicioPublico;
import Extras.Mensajes;
import Extras.TableCellRendererPropio;
import GUI.CarcelD;
import GUI.ComerciarD;
import GUI.ConstruirD;
import GUI.EnEsperaD;
import GUI.HipotecarD;
import GUI.PrincipalF;
import GUI.SubastaD;
import GUI.TableroF;
import GUI.TarjetaF;
import GUI.UnirseAPartidaD;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JComboBox;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

/**
 *
 * @author Francisco
 */
public class GestorCliente {

    //Listas Enlazadas y arreglos
    private Extras.LinkedList casillerosDeHipoteca;
    private Extras.LinkedList casillerosDeConstruccion;
    private final LinkedList<Jugador> jugadores;
    private String[] propiedadPorComprar;
    //Interfaces
    private final PrincipalF principalF;
    private EnEsperaD enEsperaF;
    private UnirseAPartidaD unirseAPartidaD;
    private TableroF tablero;
    private SubastaD subasta;
    private HipotecarD hipotecarD;
    private ConstruirD construirD;
    private CarcelD carcelD;
    private ComerciarD comerciarD;
    //Variables
    private String nickname;
    private String ipServidor = "localhost";
    private String nombreDuenioServicio;
    private String pieza;
    private int dado1;
    private int dado2;
    private static final int puerto = 5000;
    private HiloCliente hiloCliente;
    private boolean servidorNoExistente;
    private boolean nicknameUsado;
    private boolean servidorLleno;
    private boolean tableroActualizandose;
    private boolean dadosXServicio;
    private boolean comenzoJuego;// Se considera comenzado el juego cuando ya se tiraron los dados para saber el orden de juego
    private boolean accionPorComprar;
    private boolean hipotecaPorPreso;
    private boolean hipotecaPorSubasta;
    private boolean isEnBancaRota;
    private boolean hipotecaPorPago;

    public GestorCliente(PrincipalF principal) {
        this.principalF = principal;
        this.jugadores = new LinkedList<>();
        this.servidorNoExistente = false;
        this.dadosXServicio = false;
        this.servidorLleno = false;
        this.tableroActualizandose = false;
        this.comenzoJuego = false;
        this.accionPorComprar = false;
        this.hipotecaPorPreso = false;
        this.hipotecaPorSubasta = false;
        this.propiedadPorComprar = null;
        this.isEnBancaRota = false;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public String getIpServidor() {
        return ipServidor;
    }

    public void setIpServidor(String ipServidor) {
        this.ipServidor = ipServidor;
    }

    public void iniciarConexion() {
        hiloCliente = new HiloCliente(ipServidor, puerto, nickname, this);
        hiloCliente.start();
    }

    public synchronized void crearEnEspera() {
        try {
            wait();
            if (!servidorNoExistente) {
                //hiloCliente.notificar();
                wait();
                if (servidorLleno) {
                    informarServidorLleno();
                    hiloCliente.setCerroServidor(true);
                    return;
                }
                if (!nicknameUsado) {
                    enEsperaF = new EnEsperaD(principalF, true, this);
                    unirseAPartidaD.dispose();
                    hiloCliente.notificar();
                    this.llenarTablaEnEspera();
                    try {   
                        enEsperaF.setVisible(true);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                }
            } else {
                Mensajes.mostrarError("El servidor ingresado no existe o no está en línea");
            }
        } catch (InterruptedException ex) {
            Logger.getLogger(GestorCliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void llenarTablaEnEspera() {

        DefaultTableModel dtmTablaEnEspera = (DefaultTableModel) enEsperaF.getTable().getModel();
        for (int i = 0; i < dtmTablaEnEspera.getRowCount();) {
            dtmTablaEnEspera.removeRow(0);
        }
        Object[] o;
        for (Jugador jugadore : jugadores) {
            o = new Object[2];
            o[0] = jugadore.getNickname();
            o[1] = jugadore.getPieza();
            dtmTablaEnEspera.addRow(o);
        }

    }

    public void procesarJugadores(String jugadores) {
        int inicio = 0;
        this.jugadores.clear();
        while (true) {
            int nick = jugadores.indexOf("-", inicio);
            if (nick == -1) {
                break;
            }
            int indexPieza = jugadores.indexOf("&", nick);
            String nombre = jugadores.substring(inicio + 1, nick);
            String ficha = jugadores.substring(nick + 1, indexPieza);
            if (nombre.compareTo(this.nickname) == 0) {
                this.pieza = ficha;
            }
            this.jugadores.add(new Jugador(nombre, ficha));
            inicio = indexPieza;
        }
        this.llenarTablaEnEspera();
    }

    /*
     * 
     */
    public synchronized void servidorNotFound() {
        Mensajes.mostrarError("El servidor ingresado no existe o no está en linea.");
    }

    /**
     * @return the servidorNoExistente
     */
    public boolean isServidorNoExistente() {
        return servidorNoExistente;
    }

    /**
     * @param servidorNoExistente the servidorNoExistente to set
     */
    public void setServidorNoExistente(boolean servidorNoExistente) {
        this.servidorNoExistente = servidorNoExistente;
    }

    /**
     * @param unirseAPartidaD the unirseAPartidaD to set
     */
    public void setUnirseAPartidaD(UnirseAPartidaD unirseAPartidaD) {
        this.unirseAPartidaD = unirseAPartidaD;
    }

    public synchronized void notificar() {
        notifyAll();
    }

    public void cancelarHilo() {
        hiloCliente.cancelarCliente();
    }

    public void cancelacionServidor() {
        Mensajes.mostrarError("El servidor cerro");
        if (enEsperaF != null && enEsperaF.isShowing()) {
            enEsperaF.dispose();
        }
        if (tablero != null && tablero.isShowing()) {
            tablero.dispose();
        }
        principalF.setVisible(true);
        hiloCliente.cerrarServidor();
    }

    public void comenzarPartida() {
        enEsperaF.dispose();
        principalF.setVisible(false);
        tablero = new TableroF(this);
        tablero.setVisible(true);
    }

    public void informarResultadoDadosComienzo(int totalSacado) {
        hiloCliente.informarResultadoDadosComienzo(totalSacado);
    }

    public void informarServidorLleno() {
        Mensajes.mostrarError("Servidor Lleno. Por favor intente en otro momento");
    }

    public void habilitarTirarDados() {
        while (isTableroActualizandose()) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException ex) {
                Logger.getLogger(GestorCliente.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        tablero.getTirarDados().setEnabled(true);
    }

    public void informarResultadoTiradaDados(int totalSacado) {
        dado1 = tablero.getDado1();
        dado2 = tablero.getDado2();
        if (isDadosXServicio()) {
            hiloCliente.enviarMensaje(nickname + "-ResultadoTiradaServicio-" + dado1 + "-" + dado2 + "-" + nombreDuenioServicio);
            setDadosXServicio(false);
        } else {
            if (!estaPreso(nickname) || dado1 == dado2) {
                this.informarResultadoDadosJugador(nickname, totalSacado);
            }
            hiloCliente.enviarMensaje(nickname + "-ResultadoTirada-" + dado1 + "-" + dado2);
        }
    }

    public void avisarServidorCierre() {
        hiloCliente.enviarMensaje(nickname + "-Cerro-");
    }

    public void cerroJuego(String nickname) {
        Mensajes.mostrarError("El jugador " + nickname + " abandono el juego. Se da por terminado el juego.");
        this.tablero.setVisible(false);
        this.principalF.setVisible(true);
        hiloCliente.setCerroServidor(true);
    }

    public int getCantidadJugadores() {
        return jugadores.size();
    }

    public LinkedList<Jugador> getJugadores() {
        return jugadores;
    }

    private void actualizarTablero(String nickname, String pieza, int lugares) {
        int posicionActual, posicionFinal;
        posicionActual = this.getPosicionDeJugador(nickname);
        this.moverJugador(nickname, lugares);
        posicionFinal = this.getPosicionDeJugador(nickname);
        tablero.moverCasillero(posicionActual, posicionFinal, pieza);
    }

    private void moverJugador(String nickname, int lugares) {
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                jugador.moverPosicionTablero(lugares);
            }
        }
    }

    private int getPosicionDeJugador(String nickname) {
        for (Jugador jugadore : jugadores) {
            if (jugadore.getNickname().compareTo(nickname) == 0) {
                return jugadore.getPosicionTablero();
            }
        }
        return -1;
    }

    private void setPosicionDeJugador(String nickname, int posicion) {
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                jugador.setPosicionTablero(posicion);
            }
        }
    }

    public void mostrarMensajeError(String mensaje) {
        Mensajes.mostrarError(mensaje);
    }

    public void mostrarMensajeInfo(String mensaje) {
        Mensajes.mostrarInformacion(mensaje);
    }

    public boolean isNicknameUsado() {
        return nicknameUsado;
    }

    public void setNicknameUsado(boolean nicknameUsado) {
        this.nicknameUsado = nicknameUsado;
    }

    public void eliminarHilo() {
        this.hiloCliente = null;
    }

    public void setPrincipalVisible(boolean estado) {
        this.principalF.setVisible(estado);
    }

    public void informarResultadoDadosJugador(String nickname, int lugares) {
        String ficha = "";
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                ficha = jugador.getPieza();
            }
        }
        if (!estaPreso(nickname) || dado1 == dado2) {
            String mensaje = "El jugador " + nickname + " se mueve " + lugares + " lugares";
            this.aniadirHistorial(mensaje);
            this.actualizarTablero(nickname, ficha, lugares);
        }
    }

    public void mostrarDeseaComprar(String mensaje, String terreno) {
        boolean comprar = Mensajes.mostrar_SI_NO(mensaje);
        if (comprar) {
            hiloCliente.enviarMensaje(this.nickname + "-Compra-" + terreno);
        } else {
            hiloCliente.enviarMensaje(this.nickname + "-NoCompra-" + terreno);
        }
    }

    public LinkedList<Jugador> cantidadDeJugadoresPorCasillero(int casillero) {
        LinkedList<Jugador> jugadoresDeCasillero = new LinkedList<>();
        for (Jugador jug : jugadores) {
            if (jug.getPosicionTablero() == casillero) {
                jugadoresDeCasillero.add(jug);
            }
        }
        return jugadoresDeCasillero;
    }

    public String getPieza() {
        return pieza;
    }

    public void adquirioTerreno(String jugador, String terreno) {
        String mensaje = "El jugador " + jugador + " adquirió " + terreno;
        this.aniadirHistorial(mensaje);
        this.tablero.pintarPropiedades(terreno, jugador);
    }

    public void adquirioTerreno(String jugador, String terreno, String pagoDeSubasta) {
        String mensaje = "El jugador " + jugador + " adquirió por subasta " + terreno + " pagando " + pagoDeSubasta;
        this.aniadirHistorial(mensaje);
        this.mostrarMensajeInfo(mensaje);
        this.tablero.pintarPropiedades(terreno, jugador);
    }

    public void habilitarSubasta(String terreno, String idTerreno, String nicknameSiguienteOferta, String nicknameSiguienteAMostrar, String precioTerreno) {
        subasta = new SubastaD(tablero, false, this);
        subasta.setImagenTerreno(idTerreno);
        if (nickname.compareTo(nicknameSiguienteOferta) == 0) {
            subasta.setParticipa(true);
        } else {
            subasta.setParticipa(false);
        }
        subasta.getjL_proximoJugador().setText("Jugador Ofertando: " + nicknameSiguienteAMostrar);
        subasta.setTitulo(terreno);
        subasta.setPrecio(precioTerreno);
        subasta.setFoco();
        subasta.setVisible(true);
    }

    public void mdificarJugadorTablero() {
    }

    public void enviarOferta(int oferta) {
        String mensaje;
        if (oferta == -1) {//Se fue de la oferta
            mensaje = nickname + "-SubastaOferta-salio";
        } else if (oferta == -2) {//La compra a 1$
            mensaje = nickname + "-SubastaOferta-si";
        } else if (oferta == -3) {//No la compra nadie
            mensaje = nickname + "-SubastaOferta-no";
        } else {
            mensaje = nickname + "-SubastaOferta-" + oferta;
        }
        hiloCliente.enviarMensaje(mensaje);
    }

    public void addOfertaTablaSubasta(String jugador, int oferta) {
        JTable tablaOfertasSubasta = subasta.getTabla();
        DefaultTableModel dtmTablaSubastas = (DefaultTableModel) tablaOfertasSubasta.getModel();
        Object[] o = new Object[2];
        o[0] = jugador;
        o[1] = oferta;
        dtmTablaSubastas.addRow(o);
    }

    public void corroborarPosibilidadDeOferta(String nicknameSiguienteOferta) {
        if (nicknameSiguienteOferta.compareTo(nickname) == 0) {
            subasta.setParticipa(true);
        }
    }

    public void aniadirHistorial(String mensaje) {
        DefaultTableModel tablaHistorial = (DefaultTableModel) tablero.getTableHistorial().getModel();
        Calendar cal = new GregorianCalendar();
        String horaActual = "";
        if (cal.get(Calendar.HOUR_OF_DAY) < 10) {
            horaActual += "0";
        }
        horaActual += cal.get(Calendar.HOUR_OF_DAY) + ":";
        if (cal.get(Calendar.MINUTE) < 10) {
            horaActual += "0";
        }
        horaActual += cal.get(Calendar.MINUTE);
        String mensajeAMostrar = horaActual + "-> " + mensaje;
        Object[] o = multiLine(mensajeAMostrar);
        for (Object o1 : o) {
            Object[] a = new Object[1];
            a[0] = o1;
            tablaHistorial.addRow(a);
        }

        tablero.getTableHistorial().changeSelection(tablaHistorial.getRowCount() - 1, 0, false, false);
    }

    private Object[] multiLine(String mensaje) {
        int cant = (mensaje.length() / 50) + 1;
        LinkedList<String> mensajes = new LinkedList<>();
        int inf = 0;
        int sup = 0;
        while (sup < mensaje.length()) {
            sup = (inf + 50) < mensaje.length() ? inf + 50 : mensaje.length();
            boolean paraAtras = mensaje.indexOf(" ", sup) < sup + 4 && mensaje.indexOf(" ", sup) != -1;
            while (sup != mensaje.length() && mensaje.charAt(sup) != ' ') {
                if (paraAtras) {
                    sup++;
                } else {
                    sup--;
                }
            }
            mensajes.add(mensaje.substring(inf == 0 ? inf : inf + 1, sup));
            inf = sup;
        }
        return mensajes.toArray();
    }

    public void disminuirDinero(String jugador, int dinero) {
        for (Jugador jugadore : jugadores) {
            if (jugador.compareTo(jugadore.getNickname()) == 0) {
                jugadore.setDinero(dinero);
            }
        }
        tablero.setMonto(dinero, jugador);
    }

    public void tirarDadosServicio(String nickDuenio) {
        tablero.cambiarLabelDadosxServicio();
        this.habilitarTirarDados();
        nombreDuenioServicio = nickDuenio;
        setDadosXServicio(true);
    }

    public void mostrarTarjeta(String nombreArchivo) {
        TarjetaF tarjeta = new TarjetaF();
        tarjeta.seleccionarTarjeta(nombreArchivo);
        tarjeta.star();
    }

    public void actualizarTablero(String nickname, int posicion) {
        String ficha = "";
        boolean bandera = true;
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                ficha = jugador.getPieza();
            }
        }
        int posicionActual = getPosicionDeJugador(nickname);
        setPosicionDeJugador(nickname, posicion);
        while (bandera) {
            if (tablero.isPosicionActualizada(posicionActual, ficha)) {
                try {
                    Thread.sleep(350);
                    if (posicionActual - 3 == posicion && !estaPreso(nickname)) {
                        tablero.moverCasilleroHaciaAtras(posicionActual, posicion, ficha);
                    } else {
                        tablero.moverCasillero(posicionActual, posicion, ficha);
                    }
                    bandera = false;
                } catch (InterruptedException ex) {
                }
            }
        }
        if (nickname.compareTo(this.nickname) == 0 && posicion != 10) {
            String mensaje = nickname + "-AvanceDePosicion-" + posicion;
            hiloCliente.enviarMensaje(mensaje);

        }
    }

    public void actualizarTarjetaCarcel(String nickname, String tipo) {
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                switch (tipo) {
                    case "arca":
                        jugador.cambiarSalgaCarcelArca();
                        break;
                    case "suerte":
                        jugador.cambiarSalgaCarcelSuerte();
                        break;
                }
            }
        }
        for (Jugador jugador : jugadores) {
            if (jugador.isSalgaCarcelArca()) {
                tablero.pintarPropiedades("Salga de la carcel Arca", jugador.getNickname());
                break;
            } else {
                tablero.pintarPropiedades("Salga de la carcel Arca", "Banco");
            }
        }
        for (Jugador jugador : jugadores) {
            if (jugador.isSalgaCarcelSuerte()) {
                tablero.pintarPropiedades("Salga de la carcel Suerte", jugador.getNickname());
                break;
            } else {
                tablero.pintarPropiedades("Salga de la carcel Suerte", "Banco");
            }
        }
    }

    public boolean isServidorLleno() {
        return servidorLleno;
    }

    public void setServidorLleno(boolean servidorLleno) {
        this.servidorLleno = servidorLleno;
    }

    public void actualizarEstadoCarcel(String nickname, boolean estado) {
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                jugador.setMigliore(estado);
            }
        }
    }

    public boolean estaPreso(String nickname) {
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                return jugador.isMigliore();
            }
        }
        return false;
    }

    public boolean isTableroActualizandose() {
        return tableroActualizandose;
    }

    public void setTableroActualizandose(boolean tableroActualizandose) {
        this.tableroActualizandose = tableroActualizandose;
    }

    public int getDineroEfectivo() {
        for (Jugador jugadore : jugadores) {
            if (jugadore.getNickname().compareTo(this.nickname) == 0) {
                return jugadore.getDinero();
            }
        }
        return -1;
    }

    public void terminarSubasta(String jugador) {
        if (jugador.equals("nadie")) {
            Mensajes.mostrarInformacion("Todos los jugadores abandonaron la subasta. La propiedad queda en el banco");
        }
        subasta.dispose();
    }

    public void procesarSubastaOferta(String jugador, String oferta, String nicknameSiguienteOferta, String nicknameSiguienteAMostrar) {
        if (oferta.contains("preguntarSiNo")) {
            boolean comprarA1 = Mensajes.mostrar_SI_NO("Todos renunciaron a la subasta. Desea adquirila a 1$?");
            if (comprarA1) {
                enviarOferta(-2);
            } else {
                enviarOferta(-3);
            }
            return;
        }
        if (oferta.contains("salio")) {
            Mensajes.mostrarInformacion("El jugador " + jugador + " abandono la subasta.");
            if (jugador.equals(nickname)) {
                subasta.setParticipa(false);
            }
        } else {
            int ofertaReal = Integer.parseInt(oferta);
            addOfertaTablaSubasta(jugador, ofertaReal);
        }
        subasta.getjL_proximoJugador().setText("Jugador Ofertando: " + nicknameSiguienteAMostrar);
        corroborarPosibilidadDeOferta(nicknameSiguienteOferta);
    }

    public void comenzarHipotecado() {
        this.setHaciendoAlgo(nickname, true);
        hiloCliente.enviarMensaje(nickname + "-listarPropiedades-false");
    }

    private boolean llenarPropiedadesHipoteca(String propiedades) {
        ServicioPublico s;
        Propiedad p;
        Ferrocarril f;
        int indiceBarra = propiedades.indexOf("/");
        int indiceSegundaBarra = propiedades.indexOf("/", indiceBarra + 1);
        int indiceTerceraBarra = propiedades.indexOf("/", indiceSegundaBarra + 1);
        int indiceGuion = propiedades.indexOf("-");
        int indiceUltimoGuion;
        String idCasillero = propiedades.substring(0, indiceBarra);
        if (idCasillero.compareTo("noTiene") == 0) {
            this.setHaciendoAlgo(nickname, false);
            this.mostrarMensajeError("Usted no tiene propiedades para hipotecar");
            return false;
        }
        casillerosDeHipoteca = new Extras.LinkedList();
        String nombre = propiedades.substring(indiceBarra + 1, indiceSegundaBarra);
        String color = propiedades.substring(indiceSegundaBarra + 1, indiceTerceraBarra);
        String valorHipotecario;
        if (indiceGuion != -1) {
            valorHipotecario = propiedades.substring(indiceTerceraBarra + 1, indiceGuion);
        } else {
            valorHipotecario = propiedades.substring(indiceTerceraBarra + 1);
        }
        if (color.compareTo("Servicio") == 0) {
            s = new ServicioPublico(Integer.parseInt(idCasillero), color, nombre);
            s.setValorHipotecario(Integer.parseInt(valorHipotecario));
            casillerosDeHipoteca.addinOrder(s);
        } else if (color.compareTo("Ferrocarril") == 0) {
            f = new Ferrocarril(Integer.parseInt(idCasillero), color, nombre);
            f.setValorHipotecario(Integer.parseInt(valorHipotecario));
            casillerosDeHipoteca.addinOrder(f);
        } else {
            p = new Propiedad();
            p.setIdCasillero(Integer.parseInt(idCasillero));
            p.setColor(color);
            p.setNombre(nombre);
            p.setTipo("Propiedad");
            p.setValorHipotecario(Integer.parseInt(valorHipotecario));
            casillerosDeHipoteca.addinOrder(p);
        }

        while (indiceGuion != -1) {
            indiceBarra = propiedades.indexOf("/", indiceGuion);
            indiceSegundaBarra = propiedades.indexOf("/", indiceBarra + 1);
            indiceTerceraBarra = propiedades.indexOf("/", indiceSegundaBarra + 1);
            indiceUltimoGuion = propiedades.indexOf("-", indiceTerceraBarra);
            idCasillero = propiedades.substring(indiceGuion + 1, indiceBarra);

            nombre = propiedades.substring(indiceBarra + 1, indiceSegundaBarra);
            color = propiedades.substring(indiceSegundaBarra + 1, indiceTerceraBarra);
            if (indiceUltimoGuion == -1) {
                valorHipotecario = propiedades.substring(indiceTerceraBarra + 1);
            } else {
                valorHipotecario = propiedades.substring(indiceTerceraBarra + 1, indiceUltimoGuion);
            }
            if (color.compareTo("Servicio") == 0) {
                s = new ServicioPublico(Integer.parseInt(idCasillero), "Servicio", nombre);
                s.setValorHipotecario(Integer.parseInt(valorHipotecario));
                casillerosDeHipoteca.addinOrder(s);
            } else if (color.compareTo("Ferrocarril") == 0) {
                f = new Ferrocarril(Integer.parseInt(idCasillero), color, nombre);
                f.setValorHipotecario(Integer.parseInt(valorHipotecario));
                casillerosDeHipoteca.addinOrder(f);
            } else {
                p = new Propiedad();
                p.setIdCasillero(Integer.parseInt(idCasillero));
                p.setColor(color);
                p.setNombre(nombre);
                p.setValorHipotecario(Integer.parseInt(valorHipotecario));
                p.setTipo("Propiedad");
                casillerosDeHipoteca.addinOrder(p);
            }
            indiceGuion = indiceUltimoGuion;
        }
        return true;
    }

    public void listarPropiedadesHipoteca(String propiedades, boolean esPorPreso) {
        if (llenarPropiedadesHipoteca(propiedades)) {
            hipotecarD = new HipotecarD(tablero, false, this, true, esPorPreso);
            llenarTablaHipoteca(hipotecarD, true);
            hipotecarD.show();
        } else {
            if (accionPorComprar) {
                hiloCliente.enviarMensaje(nickname + "-ComprarCasilla-" + propiedadPorComprar[0]);
                accionPorComprar = false;
                propiedadPorComprar = null;
            }
            if (hipotecaPorSubasta) {
                hipotecaPorSubasta = false;

            }
        }
    }

    private void llenarTablaHipoteca(HipotecarD hipotecarD, boolean hipoteca) {
        JTable tablaAHipotecar = hipotecarD.getTablaAHipotecar();
        DefaultTableModel dtm = (DefaultTableModel) tablaAHipotecar.getModel();
        Object[] fila = new Object[4];
        for (int i = 0; i < casillerosDeHipoteca.Size(); i++) {

            if (((Casillero) casillerosDeHipoteca.get(i)).getTipo().compareTo("Servicio") == 0) {
                ServicioPublico s = (ServicioPublico) casillerosDeHipoteca.get(i);
                fila[0] = s.getNombre();
                fila[1] = s.getTipo();
                fila[2] = hipoteca ? s.getValorHipotecario() : s.getCostoDeshipoteca();
                fila[3] = s.getIdCasillero();
            } else if (((Casillero) casillerosDeHipoteca.get(i)).getTipo().compareTo("Propiedad") == 0) {
                Propiedad p = (Propiedad) casillerosDeHipoteca.get(i);
                fila[0] = p.getNombre();
                fila[1] = p.getColor();
                fila[2] = hipoteca ? p.getValorHipotecario() : p.getCostoDeshipoteca();
                fila[3] = p.getIdCasillero();
            } else {
                Ferrocarril f = (Ferrocarril) casillerosDeHipoteca.get(i);
                fila[0] = f.getNombre();
                fila[1] = f.getTipo();
                fila[2] = hipoteca ? f.getValorHipotecario() : f.getCostoDeshipoteca();
                fila[3] = f.getIdCasillero();
            }
            dtm.addRow(fila);
        }
    }

    public void hipotecar(LinkedList propiedadesHipotecadas) {
        String mensaje = nickname + "-hipotecar-";
        for (int i = 0; i < propiedadesHipotecadas.size(); i++) {
            if (i == propiedadesHipotecadas.size() - 1) {
                mensaje += propiedadesHipotecadas.get(i);
            } else {
                mensaje += propiedadesHipotecadas.get(i) + "/";
            }
        }
        if (accionPorComprar) {
            mensaje += "-true;" + nickname + "-ComprarCasilla-" + propiedadPorComprar[0];
            accionPorComprar = false;
            propiedadPorComprar = null;
        }
        if (hipotecaPorPreso) {
            mensaje += "-true;" + nickname + "-HipotecoPorPreso-";
            hipotecaPorPreso = false;
        }
        if (hipotecaPorSubasta) {
            mensaje += "-true;" + nickname + "-HipotecoPorSubasta-";
            hipotecaPorSubasta = false;
        }
        if (hipotecaPorPago) {
            mensaje += "-true;" + nickname + "-PagarPorHipoConstru-";
            hipotecaPorPago = false;
        }
        this.setHaciendoAlgo(nickname, false);
        hipotecarD.dispose();
        hiloCliente.enviarMensaje(mensaje);
    }

    public void actualizarPropiedadesHipotecadas(String jugador, String propiedadesHipotecadas) {
        LinkedList listaPropiedades = new LinkedList();
        int indiceDeBarra = propiedadesHipotecadas.indexOf("/");
        String nombrePropiedad;
        if (indiceDeBarra == -1) {
            nombrePropiedad = propiedadesHipotecadas;
        } else {
            nombrePropiedad = propiedadesHipotecadas.substring(0, indiceDeBarra);
        }
        listaPropiedades.add(nombrePropiedad);
        while (indiceDeBarra != -1) {
            if (propiedadesHipotecadas.indexOf("/", indiceDeBarra + 1) == -1) {
                nombrePropiedad = propiedadesHipotecadas.substring(indiceDeBarra + 1);
            } else {
                nombrePropiedad = propiedadesHipotecadas.substring(indiceDeBarra + 1, propiedadesHipotecadas.indexOf("/", indiceDeBarra + 1));
            }
            listaPropiedades.add(nombrePropiedad);
            indiceDeBarra = propiedadesHipotecadas.indexOf("/", indiceDeBarra + 1);
        }
        tablero.hipotecarPropiedades(listaPropiedades, jugador);
    }

    public void comenzarDeshipotecado() {
        this.setHaciendoAlgo(nickname, true);
        hiloCliente.enviarMensaje(nickname + "-listarPropiedadesHipotecadas-");
    }

    public void listarPropiedadesDeshipoteca(String propiedades) {
        if (llenarPropiedadesDeshipoteca(propiedades)) {
            hipotecarD = new HipotecarD(tablero, false, this, false, false);
            llenarTablaHipoteca(hipotecarD, false);
            hipotecarD.show();
        } else {
        }
    }

    public void deshipotecar(LinkedList propiedadesHipotecadas) {
        String mensaje = nickname + "-deshipotecar-";
        for (int i = 0; i < propiedadesHipotecadas.size(); i++) {
            if (i == propiedadesHipotecadas.size() - 1) {
                mensaje += propiedadesHipotecadas.get(i);
            } else {
                mensaje += propiedadesHipotecadas.get(i) + "/";
            }
        }
        hiloCliente.enviarMensaje(mensaje);
    }

    private boolean llenarPropiedadesDeshipoteca(String propiedades) {
        ServicioPublico s;
        Propiedad p;
        Ferrocarril f;
        int indiceBarra = propiedades.indexOf("/");
        int indiceSegundaBarra = propiedades.indexOf("/", indiceBarra + 1);
        int indiceTerceraBarra = propiedades.indexOf("/", indiceSegundaBarra + 1);
        int indiceGuion = propiedades.indexOf("-");
        int indiceUltimoGuion;
        String idCasillero = propiedades.substring(0, indiceBarra);
        if (idCasillero.compareTo("noTiene") == 0) {
            Mensajes.mostrarError("Usted no tiene propiedades para deshipotecar");
            return false;
        }
        casillerosDeHipoteca = new Extras.LinkedList();
        String nombre = propiedades.substring(indiceBarra + 1, indiceSegundaBarra);
        String color = propiedades.substring(indiceSegundaBarra + 1, indiceTerceraBarra);
        String costoDeshipoteca;
        if (indiceGuion != -1) {
            costoDeshipoteca = propiedades.substring(indiceTerceraBarra + 1, indiceGuion);
        } else {
            costoDeshipoteca = propiedades.substring(indiceTerceraBarra + 1);
        }
        if (color.compareTo("Servicio") == 0) {
            s = new ServicioPublico(Integer.parseInt(idCasillero), color, nombre);
            s.setCostoDeshipoteca(Integer.parseInt(costoDeshipoteca));
            casillerosDeHipoteca.addinOrder(s);
        } else if (color.compareTo("Ferrocarril") == 0) {
            f = new Ferrocarril(Integer.parseInt(idCasillero), color, nombre);
            f.setCostoDeshipoteca(Integer.parseInt(costoDeshipoteca));
            casillerosDeHipoteca.addinOrder(f);
        } else {
            p = new Propiedad();
            p.setIdCasillero(Integer.parseInt(idCasillero));
            p.setColor(color);
            p.setNombre(nombre);
            p.setTipo("Propiedad");
            p.setCostoDeshipoteca(Integer.parseInt(costoDeshipoteca));
            casillerosDeHipoteca.addinOrder(p);
        }

        while (indiceGuion != -1) {
            indiceBarra = propiedades.indexOf("/", indiceGuion);
            indiceSegundaBarra = propiedades.indexOf("/", indiceBarra + 1);
            indiceTerceraBarra = propiedades.indexOf("/", indiceSegundaBarra + 1);
            indiceUltimoGuion = propiedades.indexOf("-", indiceTerceraBarra);
            idCasillero = propiedades.substring(indiceGuion + 1, indiceBarra);

            nombre = propiedades.substring(indiceBarra + 1, indiceSegundaBarra);
            color = propiedades.substring(indiceSegundaBarra + 1, indiceTerceraBarra);
            if (indiceUltimoGuion == -1) {
                costoDeshipoteca = propiedades.substring(indiceTerceraBarra + 1);
            } else {
                costoDeshipoteca = propiedades.substring(indiceTerceraBarra + 1, indiceUltimoGuion);
            }
            if (color.compareTo("Servicio") == 0) {
                s = new ServicioPublico(Integer.parseInt(idCasillero), "Servicio", nombre);
                s.setCostoDeshipoteca(Integer.parseInt(costoDeshipoteca));
                casillerosDeHipoteca.addinOrder(s);
            } else if (color.compareTo("Ferrocarril") == 0) {
                f = new Ferrocarril(Integer.parseInt(idCasillero), color, nombre);
                f.setCostoDeshipoteca(Integer.parseInt(costoDeshipoteca));
                casillerosDeHipoteca.addinOrder(f);
            } else {
                p = new Propiedad();
                p.setIdCasillero(Integer.parseInt(idCasillero));
                p.setColor(color);
                p.setNombre(nombre);
                p.setCostoDeshipoteca(Integer.parseInt(costoDeshipoteca));
                p.setTipo("Propiedad");
                casillerosDeHipoteca.addinOrder(p);
            }
            indiceGuion = indiceUltimoGuion;
        }
        return true;
    }

    public void actualizarPropiedadesDeshipotecadas(String jugador, String propiedadesDeshipotecadas) {
        LinkedList listaPropiedades = new LinkedList();
        int indiceDeBarra = propiedadesDeshipotecadas.indexOf("/");
        String nombrePropiedad;
        if (indiceDeBarra == -1) {
            nombrePropiedad = propiedadesDeshipotecadas;
        } else {
            nombrePropiedad = propiedadesDeshipotecadas.substring(0, indiceDeBarra);
        }
        listaPropiedades.add(nombrePropiedad);
        while (indiceDeBarra != -1) {
            if (propiedadesDeshipotecadas.indexOf("/", indiceDeBarra + 1) == -1) {
                nombrePropiedad = propiedadesDeshipotecadas.substring(indiceDeBarra + 1);
            } else {
                nombrePropiedad = propiedadesDeshipotecadas.substring(indiceDeBarra + 1, propiedadesDeshipotecadas.indexOf("/", indiceDeBarra + 1));
            }
            listaPropiedades.add(nombrePropiedad);
            indiceDeBarra = propiedadesDeshipotecadas.indexOf("/", indiceDeBarra + 1);
        }
        tablero.deshipotecarPropiedades(listaPropiedades, jugador);
        if (hipotecarD != null) {
            hipotecarD.setVisible(false);
        }
    }

    public boolean hayAlguienHaciendoAlgo() {
        for (Jugador jugador : jugadores) {
            if (jugador.isRealizandoAccion()) {
                return true;
            }
        }
        return false;
    }

    public void setHaciendoAlgo(String nickname, boolean estado) {
        for (Jugador jugadore : jugadores) {
            if (jugadore.getNickname().compareTo(nickname) == 0) {
                jugadore.setRealizandoAccion(estado);
                return;
            }
        }
    }

    public void avisarCancelacionAccion() {
        this.setHaciendoAlgo(nickname, false);
        String mensaje = nickname + "-CanceloAccion-";
        if (accionPorComprar) {
            mensaje = this.nickname + "-NoCompraC-" + propiedadPorComprar[0];
            accionPorComprar = false;
            propiedadPorComprar = null;
        }
        if (hipotecaPorSubasta) {
            mensaje = this.nickname + "-NoCompraSub-";
            hipotecaPorSubasta = false;
        }
        hiloCliente.enviarMensaje(mensaje);
    }

    public boolean estoyRealizandoAccion() {
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) == 0) {
                return jugador.isRealizandoAccion();
            }
        }
        return false;
    }

    public void comenzarConstruccion() {
        hiloCliente.enviarMensaje(nickname + "-listarPropiedadesConstruccion-");
    }

    public void comenzarDeconstruccion() {
        hiloCliente.enviarMensaje(nickname + "-listarPropiedadesDeconstruccion-");
    }

    public void listarPropiedadesConstruccion(String propiedades, boolean construir) {
        if (llenarPropiedadesConstruccion(propiedades, construir)) {
            construirD = new ConstruirD(tablero, false, this, construir);
            llenarTablaConstruccion(construirD, true);
            construirD.show();
        } else {
        }
    }

    private void llenarTablaConstruccion(ConstruirD construirD, boolean b) {
        JTable tablaALlenar = construirD.getTablaAConstruir();
        DefaultTableModel dtm = (DefaultTableModel) tablaALlenar.getModel();
        Object fila[] = new Object[6];
        for (int i = 0; i < casillerosDeConstruccion.Size(); i++) {

            Propiedad p = (Propiedad) casillerosDeConstruccion.get(i);

            fila[0] = p.getNombre();
            fila[1] = p.getColor();
            fila[2] = p.getCantCasas() == 5 ? "Hotel" : p.getCantCasas();
            fila[3] = p.getCantCasas() == 5 ? "Hotel" : p.getCantCasas();
            fila[4] = p.getIdCasillero();
            fila[5] = p.getValorCasa();
            dtm.addRow(fila);

        }
    }

    public void construir(LinkedList<Propiedad> propiedades) {
        String mensaje = nickname + "-construir-";
        for (int i = 0; i < propiedades.size(); i++) {
            Propiedad p = propiedades.get(i);
            if (i != propiedades.size() - 1) {
                mensaje += p.getIdCasillero() + "/" + p.getCantCasas() + "-";
            } else {
                mensaje += p.getIdCasillero() + "/" + p.getCantCasas();
            }
        }
        construirD.dispose();
        if (hipotecaPorPago) {
            mensaje += "+true;" + nickname + "-PagarPorHipoConstru-";
            hipotecaPorPago = false;
        }
        if (accionPorComprar) {
            mensaje += "+true;" + nickname + "-ComprarCasilla-" + propiedadPorComprar[0];
            accionPorComprar = false;
            propiedadPorComprar = null;
        }
        hiloCliente.enviarMensaje(mensaje);
    }

    private boolean llenarPropiedadesConstruccion(String propiedades, boolean construir) {
        Propiedad p;
        int indiceBarra = propiedades.indexOf("/");
        int indiceSegundaBarra = propiedades.indexOf("/", indiceBarra + 1);
        int indiceTerceraBarra = propiedades.indexOf("/", indiceSegundaBarra + 1);
        int indiceCuartaBarra = propiedades.indexOf("/", indiceTerceraBarra + 1);
        int indiceGuion = propiedades.indexOf("-");
        String idCasillero = propiedades.substring(0, indiceBarra);
        if (idCasillero.compareTo("noTiene") == 0) {
            String mensaje = construir ? "construir" : "vender";
            Mensajes.mostrarError("Usted no tiene propiedades para " + mensaje);
            return false;
        }
        casillerosDeConstruccion = new Extras.LinkedList();
        String nombre = propiedades.substring(indiceBarra + 1, indiceSegundaBarra);
        String cantCasas = propiedades.substring(indiceTerceraBarra + 1, indiceCuartaBarra);
        String color = propiedades.substring(indiceSegundaBarra + 1, indiceTerceraBarra);
        String precioCasa;
        if (indiceGuion == -1) {
            precioCasa = propiedades.substring(indiceCuartaBarra + 1);
        } else {
            precioCasa = propiedades.substring(indiceCuartaBarra + 1, indiceGuion);
        }
        p = new Propiedad();
        p.setIdCasillero(Integer.parseInt(idCasillero));
        p.setNombre(nombre);
        p.setTipo("Propiedad");
        p.setCantCasas(Integer.parseInt(cantCasas));
        p.setColor(color);
        p.setValorCasa(Integer.parseInt(precioCasa));
        casillerosDeConstruccion.addinOrder(p);

        while (indiceGuion != -1) {
            indiceBarra = propiedades.indexOf("/", indiceGuion);
            indiceSegundaBarra = propiedades.indexOf("/", indiceBarra + 1);
            indiceTerceraBarra = propiedades.indexOf("/", indiceSegundaBarra + 1);
            indiceCuartaBarra = propiedades.indexOf("/", indiceTerceraBarra + 1);
            idCasillero = propiedades.substring(indiceGuion + 1, indiceBarra);
            indiceGuion = propiedades.indexOf("-", indiceCuartaBarra + 1);

            nombre = propiedades.substring(indiceBarra + 1, indiceSegundaBarra);
            cantCasas = propiedades.substring(indiceTerceraBarra + 1, indiceCuartaBarra);
            color = propiedades.substring(indiceSegundaBarra + 1, indiceTerceraBarra);
            if (indiceGuion == -1) {
                precioCasa = propiedades.substring(indiceCuartaBarra + 1);
            } else {
                precioCasa = propiedades.substring(indiceCuartaBarra + 1, indiceGuion);
            }
            p = new Propiedad();
            p.setIdCasillero(Integer.parseInt(idCasillero));
            p.setNombre(nombre);
            p.setCantCasas(Integer.parseInt(cantCasas));
            p.setColor(color);
            p.setValorCasa(Integer.parseInt(precioCasa));
            p.setTipo("Propiedad");
            casillerosDeConstruccion.addinOrder(p);
        }
        return true;
    }

    public void actualizarConstrucciones(String propiedades) {
        String props[] = propiedades.split("-");
        for (String prop : props) {
            int idCasillero = Integer.parseInt(prop.split("/")[0]);
            int cantCasas = Integer.parseInt(prop.split("/")[1]);
            tablero.construirCasas(idCasillero, cantCasas);
        }
    }

    public void pagarSalidaCarcel() {
        mostrarMensajeInfo("Se te debitarán $50 para que salgas de la carcel");
        this.habilitarTirarDados();
    }

    public void mostrarOpcionesCarcel(boolean pagar, boolean suerte, boolean arca, boolean tercerIntento) {
        if (!tercerIntento) {
            carcelD = new CarcelD(tablero, false, this, pagar, suerte, arca, true, nickname);
            carcelD.setVisible(true);
        } else {
            if (pagar || suerte || arca) {
                carcelD = new CarcelD(tablero, false, this, pagar, suerte, arca, false, nickname);
                carcelD.setVisible(true);
            } else {
                this.hipotecaPorPreso = true;
                hiloCliente.enviarMensaje(nickname + "-listarPropiedades-true");
            }
        }
    }

    public void preguntaPagarSalidaCarcel() {
        String mensaje = "Desea pagar $50 para salir de la carcel?";
        boolean comprar = Mensajes.mostrar_SI_NO(mensaje);
        if (comprar) {
            hiloCliente.enviarMensaje(this.nickname + "-SaleCarcel-TruePagando");
        } else {
            hiloCliente.enviarMensaje(this.nickname + "-SaleCarcel-FalsePagando");
        }
    }

    public void salirCarcelPagando() {
        hiloCliente.enviarMensaje(this.nickname + "-SaleCarcel-TruePagando");
        carcelD.dispose();
    }

    public void salirCarcelTarjeta(boolean suerte, boolean arca) {
        if (suerte) {
            hiloCliente.enviarMensaje(this.nickname + "-SaleCarcel-tarjSuerte");
            carcelD.dispose();
            return;
        }
        if (arca) {
            hiloCliente.enviarMensaje(this.nickname + "-SaleCarcel-tarjArca");
            carcelD.dispose();
        }
    }

    public void tirarDadosCarcel() {
        if (hayAlguienHaciendoAlgo()) {
            if (estoyRealizandoAccion()) {
                mostrarMensajeInfo("Está realizando una acción, por favor termine para tirar los dados (Hipoteca/Deshipoteca o Construccion/Venta)");
            } else {
                mostrarMensajeInfo("Un rival está realizando una transacción(Hipoteca/Deshipoteca o Construccion/Venta).\nPor favor aguarde su finalización para tirar los dados.");
            }
            return;
        }
        tablero.tirarDados();
        carcelD.dispose();
        hiloCliente.enviarMensaje(this.nickname + "-SaleCarcel-probarSuerte");
    }

    public boolean isComenzoJuego() {
        return comenzoJuego;
    }

    public void setComenzoJuego(boolean estado) {
        this.comenzoJuego = estado;
    }

    public void setEnabledBotonesAccionesTablero(boolean estado) {
        tablero.setEnabledBotonesAcciones(estado);
    }

    public void listarPropiedadesCadaJugador(String propiedades) {
        String propJugadores[] = propiedades.split("&");
        for (String propJugadore : propJugadores) {
            String[] data = propJugadore.split("-");
            for (int j = 1; j < data.length; j++) {
                // TODO
            }
        }
    }

    public void noPuedeAdquirir(String propiedad) {
        String p[] = propiedad.split("/");
        Mensajes.mostrarError("No posee el dinero suficiente para adquirir " + p[1] + ".");
        hiloCliente.enviarMensaje(this.nickname + "-NoCompra-" + p[0]);
    }

    public void actualizarTurnoJugador(String jugador) {
        tablero.remarcarJugadorActual(jugador);
    }

    public void hipotecaSub() {
        boolean resp = Mensajes.mostrar_SI_NO("No posee el dinero suficiente para adquirir la propiedad. Desea hipotecar propiedades?");
        if (resp) {
            this.hipotecaPorSubasta = true;
            comenzarHipotecado();
        } else {
            String mensaje = nickname + "-SubastaOferta-no";
            hiloCliente.enviarMensaje(mensaje);
        }
    }

    public void adquirioTerrenos(String jugador, String propiedades) {
        if (propiedades.compareTo("noTiene") != 0) {
            String[] propiedadesSeparadas = propiedades.split("/");
            for (int i = 0; i < propiedadesSeparadas.length; i++) {
                String mensaje = "El jugador " + jugador + " adquirió " + propiedadesSeparadas[i];
                this.aniadirHistorial(mensaje);
                this.tablero.pintarPropiedades(propiedadesSeparadas[i], jugador);
            }
        }
    }

    public void bancarrota(String nombreJugador) {
        if (nombreJugador.compareTo(this.nickname) == 0) {
            this.isEnBancaRota = true;            
        }
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nombreJugador) == 0) {
                tablero.marcarJugadorEnBancarrota(nombreJugador, jugador.getPieza(), jugador.getPosicionTablero());
                jugador.setBancarrota(true);
            }
        }
        tablero.setMonto(0, nombreJugador);
    }

    public boolean getIsEnBancaRota() {
        return isEnBancaRota;
    }

    public void preguntarDeshipotecarPorBancarrota(String jugadorQueQuebro) {
        boolean resultado = Mensajes.mostrar_SI_NO("¿Desea deshipotecar las propiedades adquiridas a partir de la bancarrota de " + jugadorQueQuebro + "?");
        if (resultado) {
            comenzarDeshipotecado();
        }
    }

    public void comenzarComercio() {
        comerciarD = new ComerciarD(tablero, false, this);
        hiloCliente.enviarMensaje(nickname + "-listarPosesionesComerciar-" + nickname);
    }

    public void pedirPropiedadesOponenteComerciar(String oponenteAComerciar) {
        hiloCliente.enviarMensaje(nickname + "-listarPosesionesComerciar-" + oponenteAComerciar);
    }

    public String llenarComboContrincantes() {
        String ultimoCargado = "";
        for (Jugador jugador : jugadores) {
            if (jugador.getNickname().compareTo(nickname) != 0) {
                comerciarD.getComboContrincantes().addItem(jugador.getNickname());
            }
        }
        ultimoCargado = comerciarD.getComboContrincantes().getSelectedItem().toString();
        return ultimoCargado;
    }

    public void listarPropiedadesOponenteComerciar(String posesiones) {
        comerciarD.limpiarTablas();
        comerciarD.reiniciarBotonesOponente();
        if (posesiones.compareTo("noTiene") == 0) {
            comerciarD.setEnabledBotonesOponente(false);
        } else {
            llenarTablaPropiedadesComerciarOponente(posesiones);
        }
    }

    public void llenarTablaPropiedadesComerciarOponente(String posesiones) {
        //id/tipo/nombre/color
        if (posesiones.compareTo("noTiene") == 0) {
            return;
        }
        int id;
        String[] atributosPosesion;
        Object[] posesionFila;
        DefaultTableModel dtmTablaPropiedadesOponente = (DefaultTableModel) comerciarD.getTablaPropiedadesOponente().getModel();
        String[] posesionesIndividuales = posesiones.split("-");
        for (int i = 0; i < posesionesIndividuales.length; i++) {
            atributosPosesion = posesionesIndividuales[i].split("/");
            posesionFila = new Object[4];
            id = Integer.parseInt(atributosPosesion[0]);
            posesionFila[3] = atributosPosesion[0];
            switch (atributosPosesion[1]) {
                case "Propiedad":
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[1] = atributosPosesion[1];
                    posesionFila[2] = atributosPosesion[3];
                    break;
                case "Ferrocarril":
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[1] = atributosPosesion[1];
                    posesionFila[2] = "-";
                    break;
                case "Servicio":
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[1] = atributosPosesion[1];
                    posesionFila[2] = "-";
                    break;
                case "tarjeta":
                    if (atributosPosesion[3].compareTo("arca") == 0) {
                        posesionFila[1] = "Arca Comunal";
                    } else {
                        posesionFila[1] = "Suerte";
                    }
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[2] = "-";
                    break;
            }
            dtmTablaPropiedadesOponente.addRow(posesionFila);
        }
    }

    public void listarPropiedadesPropiasComerciar(String posesiones) {
        comerciarD.setVisible(true);
        if (posesiones.compareTo("noTiene") == 0) {
            comerciarD.setEnabledBotonesPropios(false);
        } else {
            llenarTablaPropiedadesPropiasComerciar(posesiones);
        }
    }

    private void llenarTablaPropiedadesPropiasComerciar(String posesiones) {
        if (posesiones.compareTo("noTiene") == 0) {
            return;
        }
        int id;
        String[] atributosPosesion;
        Object[] posesionFila;
        DefaultTableModel dtmTablaPropiedadesOponente = (DefaultTableModel) comerciarD.getTablaPropiedadesPropias().getModel();
        String[] posesionesIndividuales = posesiones.split("-");
        for (int i = 0; i < posesionesIndividuales.length; i++) {
            atributosPosesion = posesionesIndividuales[i].split("/");
            posesionFila = new Object[4];
            id = Integer.parseInt(atributosPosesion[0]);
            if (id == 666) {
                posesionFila[3] = "-";
            } else {
                posesionFila[3] = atributosPosesion[0];
            }
            switch (atributosPosesion[1]) {
                case "Propiedad":
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[1] = atributosPosesion[1];
                    posesionFila[2] = atributosPosesion[3];
                    break;
                case "Ferrocarril":
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[1] = atributosPosesion[1];
                    posesionFila[2] = "-";
                    break;
                case "Servicio":
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[1] = atributosPosesion[1];
                    posesionFila[2] = "-";
                    break;
                case "tarjeta":
                    if (atributosPosesion[3].compareTo("arca") == 0) {
                        posesionFila[1] = "Arca Comunal";
                    } else {
                        posesionFila[1] = "Suerte";
                    }
                    posesionFila[0] = atributosPosesion[2];
                    posesionFila[2] = "-";
                    break;
            }
            dtmTablaPropiedadesOponente.addRow(posesionFila);
        }
    }

    public void ofrecerIntercambio() {
        int dineroOfrecido = Integer.parseInt(comerciarD.getDineroOfrecido());
        String propiedadesSolicitadas = comerciarD.getPropiedadesSolicitadas();
        String propiedadesOfrecidas = comerciarD.getPropiedadesOfrecidas();
        String oponenteDeIntercambio = comerciarD.getOponenteDeIntercambio();

        String mensaje = this.nickname + "-propuestaIntercambio-" + propiedadesSolicitadas + "/" + propiedadesOfrecidas + "/" + dineroOfrecido + "/" + oponenteDeIntercambio;

        hiloCliente.enviarMensaje(mensaje);
    }

    public void mostrarPropuestaIntercambio(String mensajeArmado, String propuestaADevolver) {
        mensajeArmado = mensajeArmado.replaceAll("barraene", "\n");
        boolean resultado = Mensajes.mostrar_SI_NO(mensajeArmado);
        if (resultado) {
            hiloCliente.enviarMensaje(nickname + "-respuestaIntercambio-" + propuestaADevolver + "/Si");
        } else {
            hiloCliente.enviarMensaje(nickname + "-respuestaIntercambio-" + propuestaADevolver + "/No");
        }
    }

    public void mostrarRespuestaIntercambio(String respuesta) {
        if (respuesta.compareTo("Si") == 0) {
            Mensajes.mostrarInformacion("El oponente acepto el intercambio.");
        } else if (respuesta.compareTo("No") == 0) {
            Mensajes.mostrarInformacion("El oponente rechazo el intercambio.");
        }
        comerciarD.dispose();
    }

    public void hipotecarParaPagar(String montoAPagar) {
        this.hipotecaPorPago = true;
        this.setHaciendoAlgo(nickname, true);
        hiloCliente.enviarMensaje(nickname + "-listarPropiedades-true");
    }

    public void finJuego(String jugador) {
        if (jugador.compareTo(this.nickname) == 0) {
            //MOSTRAR INTERFAZ COPADA DE GANADOR
            Mensajes.mostrarInformacion("GANASTE LA PARTIDA!!!! GRACIAS POR JUGAR!");
        } else {
            Mensajes.mostrarInformacion("EL JUGADOR: " + jugador + " GANO LA PARTIDA! GRACIAS POR JUGAR!");
        }
        this.tablero.setVisible(false);
        this.principalF.setVisible(true);
        hiloCliente.setCerroServidor(true);
    }

    public boolean isDadosXServicio() {
        return dadosXServicio;
    }

    public void setDadosXServicio(boolean dadosXServicio) {
        this.dadosXServicio = dadosXServicio;
    }

    public void mostrarOpcionesPago(int opciones) {
        switch (opciones) {
            case 0:
                this.venderParaPagar();
                return;
            case 1:
                this.hipotecarParaPagar("");
                return;
        }
        int res = Mensajes.mostrarCustom("No tiene suficiente dinero efectivo para pagar.", new String[]{"Vender Casas", "Hipotecar Propiedades"});
        switch (res) {
            case 0:
                this.venderParaPagar();
                break;
            case 1:
                this.hipotecarParaPagar("");
                break;
        }
    }

    public void venderParaPagar() {
        this.hipotecaPorPago = true;
        comenzarDeconstruccion();
    }

    public void preguntarHipotecar(String propiedad) {
        String p[] = propiedad.split("/");
        String mensaje = "Tienes que hipotecar propiedades para adquirir " + p[1] + ", desea realizarlo ahora?";
        boolean hipotecar = Mensajes.mostrar_SI_NO(mensaje);
        if (hipotecar) {
            accionPorComprar = true;
            propiedadPorComprar = p;
            this.comenzarHipotecado();
        } else {
            hiloCliente.enviarMensaje(this.nickname + "-NoCompra-" + p[0]);
        }
    }

    public void preguntarVenderCasas(String propiedad) {
        String p[] = propiedad.split("/");
        String mensaje = "Tienes que vender casas para adquirir " + p[1] + ", desea realizarlo ahora?";
        boolean venderCasas = Mensajes.mostrar_SI_NO(mensaje);
        if (venderCasas) {
            accionPorComprar = true;
            propiedadPorComprar = p;
            this.comenzarDeconstruccion();
        } else {
            hiloCliente.enviarMensaje(this.nickname + "-NoCompra-" + p[0]);
        }
    }

    public void preguntarVenderHipotecar(String propiedad) {
        String p[] = propiedad.split("/");
        int res = Mensajes.mostrarCustom("No tiene suficiente dinero efectivo para adquirir " + p[1] + ".", new String[]{"Vender Casas", "Hipotecar Propiedades", "No Adquirir"});
        switch (res) {
            case 0:
                accionPorComprar = true;
                propiedadPorComprar = p;
                this.comenzarDeconstruccion();
                break;
            case 1:
                accionPorComprar = true;
                propiedadPorComprar = p;
                this.comenzarHipotecado();
                break;
            case 2:
                hiloCliente.enviarMensaje(this.nickname + "-NoCompra-" + p[0]);
                break;
        }
    }
}
